Contention for Critical Sections Can Reduce Performance and Scalability by Causing Thread Serialization. the Proposed Accelerated Critical Sections Mechanism Reduces This Limitation. Acs Executes Critical Sections on the High-performance Core of an Asymmetric Chip Multiprocessor

......Extracting high performance from chip multiprocessors (CMPs) requires partitioning the application into threads that execute concurrently on multiple cores. Because threads cannot be allowed to update shared data concurrently, accesses to shared data are encapsulated inside critical sections. Only one thread executes a critical section at a given time; other threads wanting to execute the same critical section must wait. Critical sections can serialize threads, thereby reducing performance and scalability (that is, the number of threads at which performance saturates). Shortening the execution time inside critical sections can reduce this performance loss. This article proposes the accelerated critical sections mechanism. ACS is based on the asymmetric chip multiprocessor, which consists of at least one large, high-performance core and many small, power-efficient cores (see the ‘‘Related work’’ sidebar for other work in this area). The ACMP was originally proposed to run Amdahl’s serial bottleneck (where only a single thread exists) more quickly on the large core and the parallel program regions on the multiple small cores. In addition to Amdahl’s bottleneck, ACS runs selected critical sections on the large core, which runs them faster than the smaller cores. ACS dedicates the large core exclusively to running critical sections (and the Amdahl’s bottleneck). In conventional systems, when a core encounters a critical section, it acquires the lock for the critical section, executes the critical section, and releases the lock. In ACS, when a small core encounters a critical section, it sends a request to the large core for execution of that critical section and stalls. The large core executes the critical section and notifies the small core when it has completed the critical section. The small core then resumes execution. By accelerating critical section execution, ACS reduces serialization, lowering the likelihood of threads waiting for a critical section to finish. Our evaluation on a set of 12 criticalsection-intensive workloads shows that ACS reduces the average execution time by 34 percent compared to an equal-area 32-core [3B2-9] mmi2010010060.3d 10/2/010 17:56 Page 60